Spire C/C++

Embedded systems solutions for complex C and C++ applications

A solution for every embedded application need
- C only embedded applications
- C/C++ embedded applications
- C or C/C++ real-time applications
Support for multiple embedded target processors, including:
- Motorola 68K and CPU-32 families
- PowerPC family
- MIPS R3000/R4000 family
- Intel x86 family
Extensive support for demanding embedded applications
Extremely powerful support for debugging
Compact, high-performance executables
Real-time performance capability
A scalable solution for small projects or those with millions of lines of code
Common feature set and "look and feel" across all development host platforms
A solution that is easy to learn and use
A proven, reliable technology

Rational's Spire(TM) family of C/C++ cross-development systems consists of mature, production-quality, optimizing cross-compilers and related tools to help you compile, debug, tune, and deliver your application. Spire C/C++ is available for most popular embedded-systems targets. All Spire C/C++ cross-development systems are built from a common code base, so they offer a common user interface and common functionality across all host platforms and embedded targets. Spire C/C++ products are fundamental components of Rational's modern, software-engineering solution, comprising software processes, integrated software-development tools, and professional services. The complete Rational solution gives you control of your software-development efforts and sharpens your competitive edge.

Satisfies every C/C++ embedded and real-time application need

Spire C/C++ provides comprehensive, easy-to-use support for host-to-target development of real-time embedded systems requiring the use of C or C++. The Spire C/C++ family supports the proposed ANSI C++ standard, ANSI C, and K&R C. Each member of the Spire family is available in two forms: Spire C for projects using only C and Spire C/C++ for projects mixing C and C++ or moving from C to C++. The Spire C/C++ family includes all the tools needed for fast, efficient cross development.

Brings you higher development productivity

Each Spire product includes--in addition to the cross-compiler--a code optimizer, a Motif-based symbolic debugger, a disassembler, a set of ANSI C and/or ANSI C++ standard libraries, and extensive online help. Spire C/C++ also includes a compilation library manager that helps you organize the components of a large program by establishing multiple libraries based on your specific project needs. The ANSI C and C++ libraries included in every Spire solution work on top of SpireExec(TM) and other real-time kernels.

Optimizes your code for high performance

Spire C/C++ compilers are optimizing compilers that give you the performance you need for demanding embedded applications. Each Spire C/C++ compiler offers ten different user-selectable levels of code optimization. Optimization techniques include:

Code straightening
Constant folding
Copy, value, and range propagation
Hoisting of loop-invariant code
Elimination of common subexpressions and redundant branches
Strength reduction on induction expressions
Removal of dead variable assignments
Sophisticated register allocation and management
Peephole optimization

Spire C/C++ code generators for RISC architectures perform additional instruction scheduling, and the code generators for all architectures generate hardware floating-point instructions when appropriate. Spire produces code that is fast, compact, and efficient. It minimizes the size of your application and maximizes its performance.

Reduces turnaround time and application size dramatically

Even though the Spire compilers are very fast, linking large programs can be a bottleneck. To solve this problem, the Spire cross-linker was designed to be fast, so you can quickly edit, compile, link, and then test your code. For instance, Spire minimizes object file symbolics to reduce the amount of work the linker must do. The Spire cross-linker's selective linking capability, a significant advantage, creates the smallest possible executable by including only the subprograms and data your application requires. This capability can be quite important when used in conjunction with C++ development where class libraries can be very large. Selective linking can effectively remove members not used in the executable and make class libraries far more practical for embedded systems.

Features flexible, complete download and board support packages

Spire products come with a complete host-to-target, embedded-systems-oriented feature set to make your download-execute-debug cycle easier. Different download communication options are available to meet your specific needs, including coverage for Ethernet, serial, emulator, simulator, or custom use. Sample configurations for serial and Ethernet download are included in the product.

Complete off-the-shelf board support packages (BSPs) are available for some of the most popular boards for each microprocessor family. Spire includes sample source code of the available BSPs if you need to customize hardware support. And it's easy to integrate the provided BSPs with your own compilation, linking, download, and debug strategy.

Provides a high-performance real-time kernel option

Rational supplies an optional, compact real-time kernel called SpireExec. It is an implementation of the POSIX threads standard and is fully compliant with POSIX 1003.1c. SpireExec supports real-time primitives such as mailboxes, semaphores, interrupt service routines, and multiple programs to give you more control over your real-time applications. SpireExec offers flexible memory management, I/O support, timer support, and support for intraprogram synchronization using POSIX threads. The small, fast, and efficient SpireExec can be easily configured and tailored to customized target systems. SpireExec is also ROMable and scales in size according to the features required by your application.

Supports your favorite off-the-shelf, third-party, real-time solution

Spire C/C++ products can be used in conjunction with other real-time products. SpireWorks(TM) C/C++, a member of the Spire family, supports Wind River System's VxWorks by handling debugging of VxWorks real-time tasks. This operating-system-aware debug facility greatly enhances your ability to compile, link, and debug real-time applications using the VxWorks operating system. Real-time solutions from other vendors are planned in the future. Contact Rational for further availability information.

Offers a powerful, nonintrusive debugger

Spire C/C++ products include a Motif-based windowing symbolic debugger. Because the Spire debugger gets its symbolic information from the compilation library instead of from your executables, you can debug without recompiling.

The Spire debugger fully supports source-level and machine-level debugging. Primary debugger features include:

Full support for debugging C++ code
- View class objects
- Step into or over constructors, destructors, or inline code
- Break on exceptions
- Visit (browse) member functions from the source-code usage
Support for character I/O from the target to the host using printf/scanf functions
File access from target to host disks
Ability to call any function with user-entered parameters, which is very useful for unit testing
Minimally intrusive target debug monitor that does not impact execution speed
Single-stepping over instructions and over calls, including display and navigation through the call stack
Setting breakpoints at source-level statements, at instructions, or at the beginnings of subprograms
Ability to examine and modify the values of memory locations, registers, and complex data structures
Setting conditional breakpoints and specifying automatic actions at breakpoints

The Spire debugger allows interactive subprogram calls and character I/O from the target, so you can write and use sophisticated debugging instrumentation subprograms. It provides extensive command logging and scripting capabilities to automate your debugging activities and make them reproducible. The debugger understands all Spire runtime options, giving you a single, consistent debugger model even if you use the additional real-time mechanisms provided by SpireExec. Using the browsing capabilities of the Spire debugger, you can quickly understand the behavior of your program.

The Motif-based Spire C/C++ debugger is powerful, flexible, and easy to use.

Debugs optimized code

With Spire, you debug the fully optimized code that will run in your fielded application. You never need to recompile your code with optimizations turned off to use the debugger. You save time and have increased confidence in your application because you can debug the executable you will deploy.

The combination of Spire C/C++ and SpireSim allows testing on your host
and full support for developing for the target.

Debugs your embedded systems in real time

The Spire cross-compilers include the Spire debugger in cross-development mode to make it easy to test and debug embedded systems. You download and debug directly from the host, choosing the host-to-target communications link that best meets your project's needs: RS232, Ethernet, or emulator. Because the target debug monitor is a stand-alone, system-level debugging agent, you can debug at the lowest levels--interrupt service routines or kernel configuration code--not just at the application level. The Spire symbolic debugger can also serve as the interface for your in-circuit emulator. Trace buffers record signals from every buffer cycle out of the CPU, so you can review the buffer and analyze the course of debugging.

Provides multiplatform support

The entire Spire family is built from a shared base of source code. The "look and feel," compiler details, debugger operations, interface to the runtime executive, and most other product features are identical for Spire on all platforms.

The hardware independence of Spire enables you to work on the hardware of your choice, to share software among dissimilar hardware systems, and to develop software programs on multiple hosts. Source code, scripts, and makefiles are extremely portable from one member of the Spire family to another. You can change host or target hardware as your requirements change, without changing your application code or retraining your development team.

Brings you field-proven reliability

Code generation, debug, and runtime technologies in the Spire C/C++ compiler family have been successfully used for over ten years, both in-house at Rational and on some of the world's most demanding software projects. They have been proven on projects ranging from thousands to millions of lines of code.

From the shipment of our first products over a decade ago, Rational Software Corporation has focused on maximizing customer productivity and providing the precision, scalability, and robustness that programmers expect from their tools. Spire C/C++ reflects our experience in supporting some of the largest, most sophisticated applications worldwide. We have designed, refined, and expanded Spire to implement features demanded by real-world programmers. Spire meets the most stringent program needs, because we have paid attention to the performance demands of our customers.

Works with other tools to provide a complete solution

Spire allows you to work with your favorite standard UNIX tools, such as make, lex, yacc, and tags. It provides messages suitable for either emacs or vi editors. And the Spire family also includes optional tools to give you an even more complete development solution.

SpireAnalysis(TM) gives you nonintrusive coverage analysis, performance profiling, and program tracing and debugging capabilities to help you rapidly understand and tune your application's behavior.

SpireSim(TM) provides efficient, instruction-level simulation of major target architectures, allowing you to develop and test your program on the host system even before your embedded hardware is available. You can use the Spire debugger in concert with SpireSim to analyze and debug your application as it runs on the simulator, just as you would use the debugger on a program running on the embedded hardware. SpireSim:

Lets you develop and debug code before the hardware is available or if hardware is a scarce resource
Is less expensive than additional target hardware
Loads target code very quickly (because it is actually host memory) so the edit-compile-link-download cycle is faster for big programs
Provides an instruction-trace history to find the cause of identified bugs
Generates cache hit/miss counts to discover relative cache usage
Generates instruction-set statistics

Provides a scalable and upgradable path to Rational's development environment products

Rational Apex(R) C/C++ combines a graphical user interface with powerful development and code-management tools to provide an unmatched environment to handle the most challenging C/C++ application-development projects. Rational Apex C/C++ helps enforce your software architecture and control parallel development by teams of software engineers, resulting in cost reduction, minimization of risks, and improvement in the quality of your software. And because Spire C/C++ products use the same front-end, code generation, and debugger technology integral to Rational Apex C/C++, the transition from the Spire cross-compilation system to the full Rational Apex C/C++ environment is easy. You can start with Spire C/C++ and grow into the Rational Apex C/C++ environment when your project or staff begins to scale up.

Available development platforms

Spire C/C++ cross-compilers are available for popular host and target platforms, including SPARC-based systems running SunOS or Solaris, HP 9000 Series 700/800 systems running HP-UX, and Digital Alpha AXP systems running Digital UNIX. Please contact your Rational representative for an up-to-date list of other supported platforms.

Multitarget processor support

The Spire C/C++ family supports most of the popular microprocessors and microcontrollers on the market today.

68K family

MC68020
MC68EC020
MC68030
MC68EC030
MC68040
MC68EC040
MC68LC040
MC68060

CPU-32 family

MC68330
MC68331
MC68332
MC68333
MC68340
MC68360

MIPS R3000/R4000 family

R3000
R3001
R3041
R3051
R3052
R3081
R3500
R3800
LR33000
LR33020
LR33050
R4000
R4200
R4400
R4600

PowerPC family

601
603
604
620
(400, 500 series support planned*)

Intel x86 family

(i386, i486, Pentium support planned*)

* Contact Rational for further availability information.